package model

import (
	"fmt"
	"gorm.io/gorm"
	"time"
)

type _WkbGroupChatMessageMgr struct {
	*_BaseMgr
}

// WkbGroupChatMessageMgr open func
func WkbGroupChatMessageMgr(db *gorm.DB) *_WkbGroupChatMessageMgr {
	if db == nil {
		panic(fmt.Errorf("WkbGroupChatMessageMgr need init by db"))
	}
	ctx, cancel := context.WithCancel(context.Background())
	return &_WkbGroupChatMessageMgr{_BaseMgr: &_BaseMgr{DB: db.Table("wkb_im_group_chat_message"), isRelated: globalIsRelated, ctx: ctx, cancel: cancel, timeout: -1}}
}

// GetTableName get sql table name.获取数据库名字
func (obj *_WkbGroupChatMessageMgr) GetTableName() string {
	return "wkb_im_group_chat_message"
}

// Get 获取
func (obj *_WkbGroupChatMessageMgr) Get() (result WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Find(&result).Error
	if err == nil && obj.isRelated {
		if err = obj.New().Table("wkb_im_group").Where("group_id = ?", result.ToUserID).Find(&result.WkbGroup).Error; err != nil { // 群聊
			if err != gorm.ErrRecordNotFound { // 非 没找到
				return
			}
		}
	}

	return
}

// Gets 获取批量结果
func (obj *_WkbGroupChatMessageMgr) Gets() (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

//////////////////////////option case ////////////////////////////////////////////

// WithID id获取 id
func (obj *_WkbGroupChatMessageMgr) WithID(id uint32) Option {
	return optionFunc(func(o *options) { o.query["id"] = id })
}

// WithFromUserID from_user_id获取 发送用户 Id
func (obj *_WkbGroupChatMessageMgr) WithFromUserID(fromUserID string) Option {
	return optionFunc(func(o *options) { o.query["from_user_id"] = fromUserID })
}

// WithToUserID to_user_id获取 目标 Id
func (obj *_WkbGroupChatMessageMgr) WithToUserID(toUserID string) Option {
	return optionFunc(func(o *options) { o.query["to_user_id"] = toUserID })
}

// WithObjectName object_name获取 消息类型 文本消息 RC:TxtMsg 、 图片消息 RC:ImgMsg 、语音消息 RC:VcMsg 、图文消息 RC:ImgTextMsg 、位置消息 RC:LBSMsg 、添加联系人消息 RC:ContactNtf 、提示条通知消息 RC:InfoNtf 、资料通知消息 RC:ProfileNtf 、通用命令通知消息 RC:CmdNtf
func (obj *_WkbGroupChatMessageMgr) WithObjectName(objectName string) Option {
	return optionFunc(func(o *options) { o.query["object_name"] = objectName })
}

// WithContent content获取 消息类型
func (obj *_WkbGroupChatMessageMgr) WithContent(content string) Option {
	return optionFunc(func(o *options) { o.query["content"] = content })
}

// WithChannelType channel_type获取 会话类型
func (obj *_WkbGroupChatMessageMgr) WithChannelType(channelType string) Option {
	return optionFunc(func(o *options) { o.query["channel_type"] = channelType })
}

// WithMsgTimestamp msg_timestamp获取 服务端收到客户端发送消息时的服务器时间（1970年到现在的毫秒数）
func (obj *_WkbGroupChatMessageMgr) WithMsgTimestamp(msgTimestamp string) Option {
	return optionFunc(func(o *options) { o.query["msg_timestamp"] = msgTimestamp })
}

// WithMsgUId msg_uid获取 可通过 msgUID 确定消息唯一
func (obj *_WkbGroupChatMessageMgr) WithMsgUId(msgUId string) Option {
	return optionFunc(func(o *options) { o.query["msg_uid"] = msgUId })
}

// WithSensitiveType sensitive_type获取 消息中是否含有敏感信息，0 为不包含，1 为含有屏蔽敏感词，2 为含有替换敏感词
func (obj *_WkbGroupChatMessageMgr) WithSensitiveType(sensitiveType int8) Option {
	return optionFunc(func(o *options) { o.query["sensitive_type"] = sensitiveType })
}

// WithSource source获取 标识消息的发送源头
func (obj *_WkbGroupChatMessageMgr) WithSource(source string) Option {
	return optionFunc(func(o *options) { o.query["source"] = source })
}

// WithUpdatedAt updated_at获取 更新时间
func (obj *_WkbGroupChatMessageMgr) WithUpdatedAt(updatedAt time.Time) Option {
	return optionFunc(func(o *options) { o.query["updated_at"] = updatedAt })
}

// WithCreatedAt created_at获取 创建时间
func (obj *_WkbGroupChatMessageMgr) WithCreatedAt(createdAt time.Time) Option {
	return optionFunc(func(o *options) { o.query["created_at"] = createdAt })
}

// GetByOption 功能选项模式获取
func (obj *_WkbGroupChatMessageMgr) GetByOption(opts ...Option) (result WkbGroupChatMessage, err error) {
	options := options{
		query: make(map[string]interface{}, len(opts)),
	}
	for _, o := range opts {
		o.apply(&options)
	}

	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where(options.query).Find(&result).Error
	if err == nil && obj.isRelated {
		if err = obj.New().Table("wkb_im_group").Where("group_id = ?", result.ToUserID).Find(&result.WkbGroup).Error; err != nil { // 群聊
			if err != gorm.ErrRecordNotFound { // 非 没找到
				return
			}
		}
	}

	return
}

// GetByOptions 批量功能选项模式获取
func (obj *_WkbGroupChatMessageMgr) GetByOptions(opts ...Option) (results []*WkbGroupChatMessage, err error) {
	options := options{
		query: make(map[string]interface{}, len(opts)),
	}
	for _, o := range opts {
		o.apply(&options)
	}

	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where(options.query).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

//////////////////////////enume case ////////////////////////////////////////////

// GetFromID 通过id获取内容 id
func (obj *_WkbGroupChatMessageMgr) GetFromID(id uint32) (result WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("id = ?", id).Find(&result).Error
	if err == nil && obj.isRelated {
		if err = obj.New().Table("wkb_im_group").Where("group_id = ?", result.ToUserID).Find(&result.WkbGroup).Error; err != nil { // 群聊
			if err != gorm.ErrRecordNotFound { // 非 没找到
				return
			}
		}
	}

	return
}

// GetBatchFromID 批量唯一主键查找 id
func (obj *_WkbGroupChatMessageMgr) GetBatchFromID(ids []uint32) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("id IN (?)", ids).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetFromFromUserID 通过from_user_id获取内容 发送用户 Id
func (obj *_WkbGroupChatMessageMgr) GetFromFromUserID(fromUserID string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("from_user_id = ?", fromUserID).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetBatchFromFromUserID 批量唯一主键查找 发送用户 Id
func (obj *_WkbGroupChatMessageMgr) GetBatchFromFromUserID(fromUserIDs []string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("from_user_id IN (?)", fromUserIDs).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetFromToUserID 通过to_user_id获取内容 目标 Id
func (obj *_WkbGroupChatMessageMgr) GetFromToUserID(toUserID string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("to_user_id = ?", toUserID).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetBatchFromToUserID 批量唯一主键查找 目标 Id
func (obj *_WkbGroupChatMessageMgr) GetBatchFromToUserID(toUserIDs []string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("to_user_id IN (?)", toUserIDs).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetFromObjectName 通过object_name获取内容 消息类型 文本消息 RC:TxtMsg 、 图片消息 RC:ImgMsg 、语音消息 RC:VcMsg 、图文消息 RC:ImgTextMsg 、位置消息 RC:LBSMsg 、添加联系人消息 RC:ContactNtf 、提示条通知消息 RC:InfoNtf 、资料通知消息 RC:ProfileNtf 、通用命令通知消息 RC:CmdNtf
func (obj *_WkbGroupChatMessageMgr) GetFromObjectName(objectName string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("object_name = ?", objectName).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetBatchFromObjectName 批量唯一主键查找 消息类型 文本消息 RC:TxtMsg 、 图片消息 RC:ImgMsg 、语音消息 RC:VcMsg 、图文消息 RC:ImgTextMsg 、位置消息 RC:LBSMsg 、添加联系人消息 RC:ContactNtf 、提示条通知消息 RC:InfoNtf 、资料通知消息 RC:ProfileNtf 、通用命令通知消息 RC:CmdNtf
func (obj *_WkbGroupChatMessageMgr) GetBatchFromObjectName(objectNames []string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("object_name IN (?)", objectNames).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetFromContent 通过content获取内容 消息类型
func (obj *_WkbGroupChatMessageMgr) GetFromContent(content string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("content = ?", content).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetBatchFromContent 批量唯一主键查找 消息类型
func (obj *_WkbGroupChatMessageMgr) GetBatchFromContent(contents []string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("content IN (?)", contents).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetFromChannelType 通过channel_type获取内容 会话类型
func (obj *_WkbGroupChatMessageMgr) GetFromChannelType(channelType string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("channel_type = ?", channelType).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetBatchFromChannelType 批量唯一主键查找 会话类型
func (obj *_WkbGroupChatMessageMgr) GetBatchFromChannelType(channelTypes []string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("channel_type IN (?)", channelTypes).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetFromMsgTimestamp 通过msg_timestamp获取内容 服务端收到客户端发送消息时的服务器时间（1970年到现在的毫秒数）
func (obj *_WkbGroupChatMessageMgr) GetFromMsgTimestamp(msgTimestamp string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("msg_timestamp = ?", msgTimestamp).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetBatchFromMsgTimestamp 批量唯一主键查找 服务端收到客户端发送消息时的服务器时间（1970年到现在的毫秒数）
func (obj *_WkbGroupChatMessageMgr) GetBatchFromMsgTimestamp(msgTimestamps []string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("msg_timestamp IN (?)", msgTimestamps).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetFromMsgUId 通过msg_uid获取内容 可通过 msgUID 确定消息唯一
func (obj *_WkbGroupChatMessageMgr) GetFromMsgUId(msgUId string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("msg_uid = ?", msgUId).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetBatchFromMsgUId 批量唯一主键查找 可通过 msgUID 确定消息唯一
func (obj *_WkbGroupChatMessageMgr) GetBatchFromMsgUId(msgUIds []string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("msg_uid IN (?)", msgUIds).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetFromSensitiveType 通过sensitive_type获取内容 消息中是否含有敏感信息，0 为不包含，1 为含有屏蔽敏感词，2 为含有替换敏感词
func (obj *_WkbGroupChatMessageMgr) GetFromSensitiveType(sensitiveType int8) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("sensitive_type = ?", sensitiveType).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetBatchFromSensitiveType 批量唯一主键查找 消息中是否含有敏感信息，0 为不包含，1 为含有屏蔽敏感词，2 为含有替换敏感词
func (obj *_WkbGroupChatMessageMgr) GetBatchFromSensitiveType(sensitiveTypes []int8) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("sensitive_type IN (?)", sensitiveTypes).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetFromSource 通过source获取内容 标识消息的发送源头
func (obj *_WkbGroupChatMessageMgr) GetFromSource(source string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("source = ?", source).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetBatchFromSource 批量唯一主键查找 标识消息的发送源头
func (obj *_WkbGroupChatMessageMgr) GetBatchFromSource(sources []string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("source IN (?)", sources).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetFromUpdatedAt 通过updated_at获取内容 更新时间
func (obj *_WkbGroupChatMessageMgr) GetFromUpdatedAt(updatedAt time.Time) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("updated_at = ?", updatedAt).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetBatchFromUpdatedAt 批量唯一主键查找 更新时间
func (obj *_WkbGroupChatMessageMgr) GetBatchFromUpdatedAt(updatedAts []time.Time) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("updated_at IN (?)", updatedAts).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetFromCreatedAt 通过created_at获取内容 创建时间
func (obj *_WkbGroupChatMessageMgr) GetFromCreatedAt(createdAt time.Time) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("created_at = ?", createdAt).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// GetBatchFromCreatedAt 批量唯一主键查找 创建时间
func (obj *_WkbGroupChatMessageMgr) GetBatchFromCreatedAt(createdAts []time.Time) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("created_at IN (?)", createdAts).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

//////////////////////////primary index case ////////////////////////////////////////////

// FetchByPrimaryKey primay or index 获取唯一内容
func (obj *_WkbGroupChatMessageMgr) FetchByPrimaryKey(id uint32) (result WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("id = ?", id).Find(&result).Error
	if err == nil && obj.isRelated {
		if err = obj.New().Table("wkb_im_group").Where("group_id = ?", result.ToUserID).Find(&result.WkbGroup).Error; err != nil { // 群聊
			if err != gorm.ErrRecordNotFound { // 非 没找到
				return
			}
		}
	}

	return
}

// FetchUniqueByMsgUId primay or index 获取唯一内容
func (obj *_WkbGroupChatMessageMgr) FetchUniqueByMsgUId(msgUId string) (result WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("msg_uid = ?", msgUId).Find(&result).Error
	if err == nil && obj.isRelated {
		if err = obj.New().Table("wkb_im_group").Where("group_id = ?", result.ToUserID).Find(&result.WkbGroup).Error; err != nil { // 群聊
			if err != gorm.ErrRecordNotFound { // 非 没找到
				return
			}
		}
	}

	return
}

// FetchIndexByToUserID  获取多个内容
func (obj *_WkbGroupChatMessageMgr) FetchIndexByToUserID(toUserID string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("to_user_id = ?", toUserID).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}

// FetchIndexByIDxMsguid  获取多个内容
func (obj *_WkbGroupChatMessageMgr) FetchIndexByIDxMsguid(msgUId string) (results []*WkbGroupChatMessage, err error) {
	err = obj.DB.WithContext(obj.ctx).Table(obj.GetTableName()).Where("msg_uid = ?", msgUId).Find(&results).Error
	if err == nil && obj.isRelated {
		for i := 0; i < len(results); i++ {
			if err = obj.New().Table("wkb_im_group").Where("group_id = ?", results[i].ToUserID).Find(&results[i].WkbGroup).Error; err != nil { // 群聊
				if err != gorm.ErrRecordNotFound { // 非 没找到
					return
				}
			}
		}
	}
	return
}
